package cl.fcbarcelona.ejb.services;

import java.util.List;

import javax.ejb.EJB;
import javax.ejb.Stateless;

import cl.fcbarcelona.customExceptions.BorrarActivoException;
import cl.fcbarcelona.customExceptions.BorrarPasivoException;
import cl.fcbarcelona.customExceptions.NotAPlayerException;
import cl.fcbarcelona.model.dao.ActivoDAO;
import cl.fcbarcelona.model.dao.EstadoPasivoDAO;
import cl.fcbarcelona.model.dao.PasivoDAO;
import cl.fcbarcelona.model.dao.TipoActivoDAO;
import cl.fcbarcelona.model.dao.TipoPersonalDAO;
import cl.fcbarcelona.model.dto.ActivoDTO;
import cl.fcbarcelona.model.dto.EstadoPasivoDTO;
import cl.fcbarcelona.model.dto.PasivoDTO;
import cl.fcbarcelona.model.dto.PersonalDTO;
import cl.fcbarcelona.model.dto.TipoActivoDTO;
import cl.fcbarcelona.model.dto.TipoPersonalDTO;

/**
 * Session Bean implementation class FinanzasService
 */
@Stateless
public class FinanzasService implements FinanzasServiceRemote {

	@EJB
	private ActivoDAO activoDAO;
	@EJB
	private TipoActivoDAO tipoActivoDAO;
	@EJB
	private PasivoDAO pasivoDAO;
	@EJB
	private EstadoPasivoDAO estadoPasivoDAO;
	@EJB
	private TipoPersonalDAO tipoPersonalDAO;
	
    public FinanzasService() {
        // TODO Auto-generated constructor stub
    }
    
    @Override
    public Integer agregarActivo(Integer valor, Integer tipoActivoId){
    	TipoActivoDTO tipoActivo = tipoActivoDAO.findTipoActivoById(tipoActivoId);
    	ActivoDTO activoDTO = new ActivoDTO();
    	activoDTO.setValor(valor);
    	activoDTO.setTipoActivo(tipoActivo);
    	activoDAO.agregar(activoDTO);
    	return (int)activoDTO.getId();
    	
    }
    
    @Override
    public void borrarActivo(Integer id) throws BorrarActivoException{
    	BorrarActivoException bae = new BorrarActivoException();
    	ActivoDTO activoDTO = activoDAO.findActivoById(id.longValue());
    	if(activoDTO==null)
    		throw bae;
    	activoDAO.eliminar(activoDTO);
    	
    }
        
    @Override
    public void actualizarActivo(Integer id, Integer valor, Integer tipoActivo){    	
    	ActivoDTO activoDTO = activoDAO.findActivoById(id.longValue());
    	if(valor!=null)
    		activoDTO.setValor(valor);
    	if(tipoActivo!=null)
    		activoDTO.setTipoActivo(tipoActivoDAO.findTipoActivoById(tipoActivo));
    	activoDAO.actualizar(activoDTO);
    }
    
    @Override
    public Integer agregarPasivo(Integer valor, Integer estadoPasivoId){
    	EstadoPasivoDTO estadoPasivoDTO = estadoPasivoDAO.findEstadoPasivoById(estadoPasivoId);
    	PasivoDTO pasivoDTO = new PasivoDTO();
    	pasivoDTO.setValor(valor);
    	pasivoDTO.setEstadoPasivo(estadoPasivoDTO);
    	pasivoDAO.agregar(pasivoDTO);
    	return (int)pasivoDTO.getId();
    }
    
    @Override
    public void borrarPasivo(Integer id) throws BorrarPasivoException{
    	BorrarPasivoException bpe = new BorrarPasivoException();
    	PasivoDTO pasivoDTO = pasivoDAO.findPasivoById(id.longValue());
    	if(pasivoDTO==null)
    		throw bpe;
    	pasivoDAO.eliminar(pasivoDTO);
    }
    
    @Override
    public void actualizarPasivo(Integer id, Integer valor, Integer estadoPasivoId){
    	PasivoDTO pasivoDTO = pasivoDAO.findPasivoById(id.longValue());
    	if(valor!=null)
    		pasivoDTO.setValor(valor);
    	if(estadoPasivoId!=null)
    		pasivoDTO.setEstadoPasivo(estadoPasivoDAO.findEstadoPasivoById(estadoPasivoId));
    	pasivoDAO.actualizar(pasivoDTO);
    }
    
    @Override
    public double calcularValorMercado(PersonalDTO personal) throws NotAPlayerException{
    	double valorBase = (double)personal.getValorBase();
    	double multiplier = 0;
    	if(personal.getTipoPersonal().getTipo().equals("arquero")){
    		multiplier = 1;
    	}
    	else if(personal.getTipoPersonal().getTipo().equals("defensa")){
    		multiplier = 1.2;
    	}
    	else if(personal.getTipoPersonal().getTipo().equals("mediocampista")){
    		multiplier = 1.5;
    	}
    	else if(personal.getTipoPersonal().getTipo().equals("delantero")){
    		multiplier = 1.2;
    	}
    	else
    		throw new NotAPlayerException();
    	
    	return valorBase*multiplier;
    }
    
    //TODO: Obtener total de jugadores
    @Override
    public double obtenerTotalActivos(){
    	
    	double total=0;
    	
    	
    	TipoPersonalDTO delantero = tipoPersonalDAO.findTipoPersonalByTipo("delantero");
    	TipoPersonalDTO mediocampista = tipoPersonalDAO.findTipoPersonalByTipo("mediocampista");
    	TipoPersonalDTO defensa = tipoPersonalDAO.findTipoPersonalByTipo("defensa");
    	TipoPersonalDTO arquero = tipoPersonalDAO.findTipoPersonalByTipo("arquero");
    	
    	List<PersonalDTO> delanteros = delantero.getPersonals();
    	List<PersonalDTO> mediocampistas = mediocampista.getPersonals();
    	List<PersonalDTO> defensas = defensa.getPersonals();
    	List<PersonalDTO> arqueros = arquero.getPersonals();
    	
    	for(PersonalDTO d : delanteros){
    		try {
				total+=calcularValorMercado(d);
			} catch (NotAPlayerException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	}
    	for(PersonalDTO m : mediocampistas){
    		try {
				total+=calcularValorMercado(m);
			} catch (NotAPlayerException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	}
    	for(PersonalDTO d : defensas){
    		try {
				total+=calcularValorMercado(d);
			} catch (NotAPlayerException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	}
    	for(PersonalDTO a : arqueros){
    		try {
				total+=calcularValorMercado(a);
			} catch (NotAPlayerException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	}
    	
       	List<ActivoDTO> otrosActivos = activoDAO.obtenerOtrosActivos();
    	for(ActivoDTO activo : otrosActivos){
    		double valorActivo = activo.getValor().doubleValue();
    		total+=valorActivo;
    	}
    	return total;
    }
    
    @Override
    public Integer obtenerTotalPasivos(){
    	int total=0;
    	List<PasivoDTO> pasivos = pasivoDAO.obtenerPasivos();
    	for(PasivoDTO pasivo: pasivos){
    		if(pasivo.getEstadoPasivo().getEstado().equals("pendiente"))
    			total+=pasivo.getValor();
    	}
    	return total;    	
    }
    
    @Override
    public double obtenerBalanceTotal(){
    	return obtenerTotalActivos() - obtenerTotalPasivos();
    }

}
